Micron Document
`:top
La `!`F33f`_`[syntaxe`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Syntaxe]`_`f `F33f`_`[JavaScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JavaScript]`_`f`! est un ensemble de règles qui définissent ce qui constitue un `F33f`_`[programme`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programme_informatique]`_`f valide en langage JavaScript.

>>Contents

• `F0af`_`[Origine`#origine]`_`f
• `F0af`_`[Variables`#variables]`_`f
• `F0af`_`[Types de données de base`#types-de-donn-es-de-base]`_`f
• `F0af`_`[Nombres`#nombres]`_`f
• `F0af`_`[Tableaux`#tableaux]`_`f
• `F0af`_`[Chaînes de caractères`#cha-nes-de-caract-res]`_`f
• `F0af`_`[Opérateurs`#op-rateurs]`_`f
• `F0af`_`[Arithmétiques`#arithm-tiques]`_`f
• `F0af`_`[Affectations`#affectations]`_`f
• `F0af`_`[Comparaisons`#comparaisons]`_`f
• `F0af`_`[Booléens`#bool-ens]`_`f
• `F0af`_`[Binaires`#binaires]`_`f
• `F0af`_`[Chaînes de caractères`#cha-nes-de-caract-res]`_`f
• `F0af`_`[Structures de contrôle`#structures-de-contr-le]`_`f
• `F0af`_`[Si Sinon`#si-sinon]`_`f
• `F0af`_`[Opérateur conditionnel`#op-rateur-conditionnel]`_`f
• `F0af`_`[Instruction switch`#instruction-switch]`_`f
• `F0af`_`[Boucle For`#boucle-for]`_`f
• `F0af`_`[Boucle For..in`#boucle-for-in]`_`f
• `F0af`_`[Boucle While`#boucle-while]`_`f
• `F0af`_`[Boucle Do..while`#boucle-do-while]`_`f
• `F0af`_`[Break, continue et label`#break-continue-et-label]`_`f
• `F0af`_`[Fonctions`#fonctions]`_`f
• `F0af`_`[Objets`#objets]`_`f
• `F0af`_`[Création`#cr-ation]`_`f
• `F0af`_`[Constructeur`#constructeur]`_`f
• `F0af`_`[Méthodes`#m-thodes]`_`f
• `F0af`_`[Héritage`#h-ritage]`_`f
• `F0af`_`[Exceptions`#exceptions]`_`f
• `F0af`_`[Divers`#divers]`_`f
• `F0af`_`[Casse`#casse]`_`f
• `F0af`_`[Espaces vides et points-virgules`#espaces-vides-et-points-virgules]`_`f
• `F0af`_`[Commentaires`#commentaires]`_`f
• `F0af`_`[Notes et références`#notes-et-r-f-rences]`_`f
• `F0af`_`[Bibliographie`#bibliographie]`_`f
• `F0af`_`[Voir aussi`#voir-aussi]`_`f
• `F0af`_`[Articles connexes`#articles-connexes]`_`f
• `F0af`_`[Liens externes`#liens-externes]`_`f

-─

>>Origine

`F33f`_`[Brendan Eich`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Brendan_Eich]`_`f a résumé ainsi le lignage de la `F33f`_`[syntaxe`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Syntaxe]`_`f dans le premier paragraphe JavaScript 1.1 des spécifications : « JavaScript emprunte la plupart de sa syntaxe à `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Java_(langage)]`_`f, mais hérite aussi d'`F33f`_`[Awk`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Awk]`_`f et `F33f`_`[Perl`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Perl_(langage)]`_`f, avec une influence indirecte de `F33f`_`[Self`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Self_(langage)]`_`f pour son système de prototype objet. »

>>Variables

Les `F33f`_`[variables`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Variable_(informatique)]`_`f en JavaScript n'ont pas de `F33f`_`[type`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Type_(informatique)]`_`f défini, et n'importe quelle valeur peut être stockée dans n'importe quelle variable. Les variables peuvent être déclarées avec `B100`F9d9const`f`b ou `B100`F9d9let`f`b. La différence entre ces deux mots clés est que les variables déclarées avec `B100`F9d9const`f`b ne peuvent être réaffectés alors qu'avec `B100`F9d9let`f`b si. Ces variables ont une portée au niveau du bloc de code où elles ont été déclarées.

Le mot clé `B100`F9d9var`f`b est une vieille syntaxe pour déclarer des variables qui ne doit plus être utilisée.

Voici un exemple de déclaration de variables :

`B100`F9d9const bonjour = "bonjour";`f`b
`B100`F9d9bonjour = "hello"; //provoque une erreur`f`b
`B100`F9d9`f`b
`B100`F9d9let nombre = 5;`f`b
`B100`F9d9nombre = 2; //cela va fonctionner`f`b
`B100`F9d9`f`b
`B100`F9d9if (true) {`f`b
`B100`F9d9 nombre = 9;//nous pouvons accéder à "nombre"`f`b
`B100`F9d9 const hello = "hello";`f`b
`B100`F9d9}`f`b
`B100`F9d9`f`b
`B100`F9d9console.log(hello)// provoque une erreur car "hello" est une variable propre à la condition ci-dessus`f`b

>>Types de données de base

>>>Nombres

Les nombres en JavaScript sont représentés en binaire comme des `F33f`_`[IEEE-754`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=IEEE_754]`_`f Doubles, ce qui permet une précision de 14 à 15 chiffres significatifs JavaScript FAQ 4.2 (en). Comme ce sont des `F33f`_`[nombres binaires`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Système_binaire]`_`f, ils ne représentent pas toujours exactement les `F33f`_`[nombres décimaux`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Nombre_décimal]`_`f, en particulier les `F33f`_`[fractions`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Fraction_(mathématiques)]`_`f.

Ceci pose problème quand on formate des nombres pour les afficher car JavaScript n'a pas de méthode native pour le faire. Par exemple:

`B100`F9d9alert(0.94 - 0.01); // affiche 0.9299999999999999`f`b

En conséquence, l'arrondi devrait être utilisé dès qu'un nombre est formaté pour l'affichage (en). La méthode toFixed() ne fait pas partie des spécifications de l'`F33f`_`[ECMAScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=ECMAScript]`_`f et est implémentée différemment selon l'environnement, elle ne peut donc être invoquée.

Les nombres peuvent être spécifiés dans l'une de ces notations :

`B100`F9d9345; // un "entier", bien qu'il n'y ait qu'un seul type numérique en JavaScript`f`b
`B100`F9d934.5; // un nombre flottant`f`b
`B100`F9d93.45e2; // un autre nombre flottant, équivalent à 345`f`b
`B100`F9d90377; // un entier octal égal à 255`f`b
`B100`F9d90xFF; // un entier hexadecimal égal à 255, les lettres A-F peuvent être en minuscules ou en majuscules`f`b

Dans certaines implémentations de l'ECMAScript comme l'`F33f`_`[ActionScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=ActionScript]`_`f, les couleurs sont parfois spécifiées avec des nombres entiers en écriture `F33f`_`[hexadécimale`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Système_hexadécimal]`_`f :

`B100`F9d9var colorful = new Color( '_root.shapes' );`f`b
`B100`F9d9colorful.setRGB( 0x003366 );`f`b

Le constructeur Number peut être utilisé pour réaliser une conversion numérique explicite :

`B100`F9d9const myString = "123.456"`f`b
`B100`F9d9const myNumber = Number( myString );`f`b

Quand il est utilisé comme un constructeur, un objet `*wrapper`* numérique est créé (toutefois il est peu employé) :

`B100`F9d9const myNumericWrapper = new Number( 123.456 );`f`b

>>>Tableaux

Un `F33f`_`[tableau`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Tableau_(structure_de_données)]`_`f est un ensemble d'éléments repérés par leur indice, qui est un `F33f`_`[nombre entier`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Entier_naturel]`_`f. En JavaScript, tous les objets peuvent être formés d'un ensemble d'éléments, mais les tableaux sont des objets spéciaux qui disposent de méthodes spécifiques (par exemple, `B100`F9d9join`f`b, `B100`F9d9slice`f`b, et `B100`F9d9push`f`b).

Les tableaux ont une propriété `B100`F9d9length`f`b qui représente la longueur du tableau, c'est-à-dire le nombre d'éléments qu'il peut contenir. La propriété length d'un tableau est toujours supérieure à l'indice maximal utilisé dans ce tableau (N.B. Les indices de tableaux sont numérotés à partir de zéro). Si on crée un élément de tableau avec un indice supérieur à `B100`F9d9length`f`b, `B100`F9d9length`f`b est automatiquement augmentée. Inversement, si on diminue la valeur de `B100`F9d9length`f`b, cela supprime automatiquement les éléments qui ont un indice supérieur ou égal. La propriété `B100`F9d9length`f`b est la seule caractéristique qui distingue les tableaux des autres objets.

Les éléments de tableau peuvent être accédés avec la notation normale d'accès aux propriétés d'objet :

`B100`F9d9monTableau[1];`f`b
`B100`F9d9monTableau["1"];`f`b

Les 2 notations ci-dessus sont équivalentes.

Par contre, il n'est pas possible d'utiliser la notation "point" : objet.propriété, ni d'autres représentations du nombre entier de l'indice :

`B100`F9d9monTableau.1; // déclenche une erreur de syntaxe`f`b
`B100`F9d9monTableau["01"]; // n'est pas identique à monTableau[1]`f`b

La déclaration d'un tableau peut se faire littéralement ou par l'utilisation du constructeur `B100`F9d9Array`f`b :

`B100`F9d9let monTableau = [0,1,,,4,5]; // crée un tableau de longueur 6 avec 4 éléments`f`b
`B100`F9d9monTableau = new Array(0,1,2,3,4,5); // crée un tableau de longueur 6 avec 6 éléments`f`b
`B100`F9d9monTableau = new Array(365); // crée un tableau vide de longueur 365`f`b

Les `F33f`_`[tableaux`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Tableau_(structure_de_données)]`_`f sont implémentés de façon que seuls les éléments utilisés utilisent de la mémoire ; ce sont des tableaux `*sporadiques`*. Si l'on crée un tableau monTableau de longueur 58, puis qu'on attribue `B100`F9d9monTableau[10] = 'uneValeur'`f`b et `B100`F9d9monTableau[57] = 'uneAutreValeur'`f`b, l'espace occupé correspondra seulement à ces 2 éléments, comme pour tous les objets. La propriété `B100`F9d9length`f`b du tableau restera quand même à 58.

Grâce à la déclaration littérale, on peut créer des objets similaires aux tableaux associatifs d'autres langages :

`B100`F9d9const chien = {couleur:"brun", taille:"grand"};`f`b
`B100`F9d9chien["couleur"]; // rend la valeur "brun"`f`b
`B100`F9d9chien.couleur; // rend aussi la valeur "brun"`f`b

On peut mélanger les déclarations littérales d'objets et de tableaux pour créer facilement des tableaux associatifs, multidimensionnels, ou les deux à la fois :

`B100`F9d9const chats = [{couleur:"gris", taille:"grand"},`f`b
`B100`F9d9 {couleur:"noir", taille:"petit"}];`f`b
`B100`F9d9chats[0].taille; // rend la valeur "grand"`f`b
`B100`F9d9chiens = {azor:{couleur:"brun", taille:"grand"},`f`b
`B100`F9d9 milou:{couleur:"blanc", taille:"petit"}};`f`b
`B100`F9d9chiens.milou.taille; // rend la valeur "petit"`f`b

>>>Chaînes de caractères

En Javascript la `F33f`_`[chaîne de caractères`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Chaîne_de_caractères]`_`f est considérée comme une suite de caractères. Une chaîne de caractères en JavaScript peut être directement créée en plaçant des caractères entre apostrophes (doubles ou simples) :

`B100`F9d9const salutation = "Hello, world!";`f`b
`B100`F9d9const salutMartien = 'Bonjour, amis terriens';`f`b

Les caractères d'une chaîne peuvent être accédés individuellement (ils sont considérés comme des chaînes d'un seul caractère) avec la même notation que pour les tableaux :

`B100`F9d9const a = salutation[0]; // a vaut 'H'`f`b

En JavaScript les chaînes sont immuables :

`B100`F9d9salutation[0] = "H"; // erreur`f`b

L'opérateur d'égalité == permet de comparer le contenu de deux chaînes de caractères (en tenant compte de la casse), et retourne un booléen :

`B100`F9d9const x = "world";`f`b
`B100`F9d9const compare1 = ("Hello, " + x == "Hello, world"); // compare1 vaut true`f`b
`B100`F9d9const compare2 = ("Hello, " + x == "hello, world"); // compare2 vaut false car les`f`b
`B100`F9d9 // premiers caractères des arguments`f`b
`B100`F9d9 // n'ont pas la même casse`f`b

>>Opérateurs

L'opérateur '+' est `F33f`_`[surchargé`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Surcharge_des_opérateurs]`_`f ; il est utilisé pour la concaténation de chaîne de caractères et l'addition ainsi que la conversion de chaînes de caractères en nombres.

`B100`F9d9// Concatène 2 chaînes`f`b
`B100`F9d9const a = 'Ceci';`f`b
`B100`F9d9const b = ' et cela';`f`b
`B100`F9d9alert(a + b); // affiche 'Ceci et cela'`f`b
`B100`F9d9`f`b
`B100`F9d9// Additionne deux nombres`f`b
`B100`F9d9const x = 2;`f`b
`B100`F9d9const y = 6;`f`b
`B100`F9d9alert(x + y); // affiche 8`f`b
`B100`F9d9`f`b
`B100`F9d9// Concatène une chaîne et un nombre`f`b
`B100`F9d9alert( x + '2'); // affiche '22'`f`b
`B100`F9d9`f`b
`B100`F9d9// Convertit une chaîne en nombre`f`b
`B100`F9d9const z = '4'; // z est une chaîne (le caractère 4)`f`b
`B100`F9d9alert( z + x); // affiche '42'`f`b
`B100`F9d9alert( +z + x);// affiche 6`f`b

>>>Arithmétiques

Opérateurs binaires

`B100`F9d9+ Addition`f`b
`B100`F9d9- Soustraction`f`b
`B100`F9d9* Multiplication`f`b
`B100`F9d9/ Division (retourne une valeur en virgule flottante)`f`b
`B100`F9d9% Modulo (retourne le reste de la division entière)`f`b

Opérateurs unaires

`B100`F9d9- Négation unaire (inverse le signe)`f`b
`B100`F9d9++ Incrémentation (peut être utilisé en forme préfixée ou postfixée)`f`b
`B100`F9d9-- Décrémentation (peut être utilisé en forme préfixée ou postfixée)`f`b

>>>Affectations

`B100`F9d9= Affectation`f`b
`B100`F9d9+= Ajoute et affecte`f`b
`B100`F9d9-= Soustrait et affecte`f`b
`B100`F9d9*= Multiplie et affecte`f`b
`B100`F9d9/= Divise et affecte`f`b
`B100`F9d9%= Applique le modulo et affecte`f`b

`B100`F9d9let x = 1;`f`b
`B100`F9d9x *= 3;`f`b
`B100`F9d9console.log(x); // affiche: 3`f`b
`B100`F9d9x /= 3;`f`b
`B100`F9d9console.log(x); // affiche: 1`f`b
`B100`F9d9x -= 1;`f`b
`B100`F9d9console.log(x); // affiche: 0`f`b

>>>Comparaisons

`B100`F9d9== Égal à`f`b
`B100`F9d9!= Différent de`f`b
`B100`F9d9> Supérieur à`f`b
`B100`F9d9>= Supérieur ou égal à`f`b
`B100`F9d9< Inférieur à`f`b
`B100`F9d9<= Inférieur ou égal à`f`b
`B100`F9d9`f`b
`B100`F9d9=== Identiques (égaux et du même type)`f`b
`B100`F9d9!== Non-identiques`f`b

>>>Booléens

Le langage Javascript possède 3 opérateurs `F33f`_`[booléens`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Booléen]`_`f :

`B100`F9d9&& and (opérateur logique ET)`f`b
`B100`F9d9|| or (opérateur logique OU)`f`b
`B100`F9d9! not (opérateur logique NON)`f`b

Dans une opération booléenne, toutes les valeurs sont évaluées à `B100`F9d9true`f`b (VRAI), à l'exception de :

• la valeur booléenne `B100`F9d9false`f`b (FAUX) elle-même
• le nombre 0
• une chaîne de caractères de longueur 0
• une des valeurs suivantes : `B100`F9d9null`f`b, `B100`F9d9undefined`f`b ou `B100`F9d9NaN`f`b

On peut faire explicitement la conversion d'une valeur quelconque en valeur booléenne par la fonction `B100`F9d9Boolean`f`b :

`B100`F9d9Boolean( false ); // rend false (FAUX)`f`b
`B100`F9d9Boolean( 0 ); // rend false (FAUX)`f`b
`B100`F9d9Boolean( 0.0 ); // rend false (FAUX)`f`b
`B100`F9d9Boolean( "" ); // rend false (FAUX)`f`b
`B100`F9d9Boolean( null ); // rend false (FAUX)`f`b
`B100`F9d9Boolean( undefined ); // rend false (FAUX)`f`b
`B100`F9d9Boolean( NaN ); // rend false (FAUX)`f`b
`B100`F9d9Boolean ( "false" ); // rend true (VRAI)`f`b
`B100`F9d9Boolean ( "0" ); // rend true (VRAI)`f`b

L'opérateur booléen unaire NOT `B100`F9d9!`f`b évalue d'abord la valeur booléenne de son `F33f`_`[opérande`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Opérande]`_`f, puis rend la valeur booléenne opposée :

`B100`F9d9const a = 0;`f`b
`B100`F9d9const b = 9;`f`b
`B100`F9d9!a; // rend true, car Boolean( a ) rend false`f`b
`B100`F9d9!b; // rend false, car Boolean( b ) rend true`f`b

En doublant l'opérateur `B100`F9d9!`f`b, on peut `*normaliser`* une valeur booléenne :

`B100`F9d9let arg = null;`f`b
`B100`F9d9arg = !!arg; // arg est désormais à false au lieu de null`f`b
`B100`F9d9`f`b
`B100`F9d9arg = "ChaîneQuelconqueNonVide";`f`b
`B100`F9d9arg = !!arg; // arg est désormais à true`f`b

Dans les premières implémentations de Javascript et JScript, les opérateurs booléens `B100`F9d9&&`f`b et `B100`F9d9||`f`b fonctionnaient comme leurs homologues dans d'autres langages issus du C, c'est-à-dire qu'ils rendaient toujours une valeur booléenne :

`B100`F9d9x && y; // rend true si x ET y est VRAI, sinon il rend false`f`b
`B100`F9d9x || y; // rend true si x OU y est VRAI, sinon il rend false`f`b

Dans les implantations récentes, les opérateurs booléens `B100`F9d9&&`f`b et `B100`F9d9||`f`b rendent un de leurs deux opérandes :

`B100`F9d9x && y; // rend x si x est FAUX, sinon il rend y`f`b
`B100`F9d9x || y; // rend x si x est VRAI, sinon il rend y`f`b

Ce fonctionnement provient du fait que l'évaluation s'effectue de gauche à droite. Dès que la réponse est déterminée, l'évaluation s'arrête :

• `B100`F9d9x && y`f`b est nécessairement FAUX si `B100`F9d9x`f`b est FAUX, ce n'est pas la peine d'évaluer `B100`F9d9y`f`b
• `B100`F9d9x || y`f`b est nécessairement VRAI si `B100`F9d9x`f`b est VRAI, ce n'est pas la peine d'évaluer `B100`F9d9y`f`b

Ce nouveau comportement est peu connu, même parmi les développeurs Javascript expérimentés, et peut causer des problèmes si on s'attend à recevoir une valeur booléenne.

>>>Binaires

Opérateurs binaires

`B100`F9d9& And  : et binaire`f`b
`B100`F9d9| Or  : ou binaire`f`b
`B100`F9d9^ Xor  : ou binaire exclusif`f`b
`B100`F9d9`f`b
`B100`F9d9<< Shift left  : décalage à gauche avec remplissage à droite avec 0)`f`b
`B100`F9d9>> Shift right : décalage à droite avec conservation du bit de signe (le bit de gauche, celui du signe, est décalé vers la droite et recopié à son emplacement)`f`b
`B100`F9d9>>> Shift right : décalage à droite sans conservation du bit de signe (avec remplissage à gauche avec 0)`f`b
`B100`F9d9`f`b
`B100`F9d9 Pour les nombres positifs, >> et >>> donnent le même résultat`f`b

Opérateur unaire

`B100`F9d9~ Not : inverse tous les bits`f`b

Affectation

`B100`F9d9&= Et binaire puis affectation`f`b
`B100`F9d9|= Ou binaire puis affectation`f`b
`B100`F9d9^= Ou exclusif binaire puis affectation`f`b
`B100`F9d9<<= Décalage binaire à gauche puis affectation`f`b
`B100`F9d9>>= Décalage binaire à droite avec conservation du bit de signe puis affectation`f`b
`B100`F9d9>>>= Décalage binaire à droite sans conservation du bit de signe puis affectation`f`b

>>>Chaînes de caractères

`B100`F9d9= Assignation`f`b
`B100`F9d9+ Concaténation`f`b
`B100`F9d9+= Concatène et assigne`f`b

`B100`F9d9str = "ab" + "cd"; // rend "abcd"`f`b
`B100`F9d9str += "e"; // rend "abcde"`f`b

>>Structures de contrôle

>>>Si Sinon

`B100`F9d9 if (expression1)`f`b
`B100`F9d9 {`f`b
`B100`F9d9 //instructions réalisées si expression1 est vraie;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 else if (expression2)`f`b
`B100`F9d9 {`f`b
`B100`F9d9 //instructions réalisées si expression1 est fausse et expression2 est vraie;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 else`f`b
`B100`F9d9 {`f`b
`B100`F9d9 //instructions réalisées dans les autres cas;`f`b
`B100`F9d9 }`f`b

Dans chaque structure `*if..else`*, la branche `*else `* :

• est facultative
• peut contenir une autre structure `*if..else`*

>>>Opérateur conditionnel

L'opérateur conditionnel crée une expression qui, en fonction d'une condition donnée, prend la valeur de l'une ou l'autre de 2 expressions données. Son fonctionnement est similaire à celui de la structure `*si..sinon`* qui, en fonction d'une condition donnée, exécute l'une ou l'autre de 2 instructions données. En ce sens on peut dire que l'opérateur conditionnel est aux expressions ce que la structure `*si..sinon`* est aux instructions.

`B100`F9d9const resultat = (condition) ? expression1 : expression2;`f`b

Le code ci-dessus, qui utilise l'opérateur conditionnel, a le même effet que le code ci-dessous, qui utilise une structure `*si..sinon`* :

`B100`F9d9 if (condition)`f`b
`B100`F9d9 {`f`b
`B100`F9d9 const resultat = expression1;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 else`f`b
`B100`F9d9 {`f`b
`B100`F9d9 const resultat = expression2;`f`b
`B100`F9d9 }`f`b

Contrairement à la structure `*si..sinon`*, la partie correspondant à la branche `*sinon`* est obligatoire.

`B100`F9d9const resultat = (condition) ? expression1; // incorrect car il manque la valeur à prendre si condition est fausse`f`b

>>>Instruction switch

L'instruction switch remplace une série de `*si..sinon`* pour tester les nombreuses valeurs que peut prendre une expression :

`B100`F9d9 switch (expression) {`f`b
`B100`F9d9 case UneValeur:`f`b
`B100`F9d9 // instructions réalisées si expression=UneValeur;`f`b
`B100`F9d9 break;`f`b
`B100`F9d9 case UneAutreValeur:`f`b
`B100`F9d9 // instructions réalisées si expression=UneAutreValeur;`f`b
`B100`F9d9 break;`f`b
`B100`F9d9 default:`f`b
`B100`F9d9 // instructions réalisées dans les autres cas;`f`b
`B100`F9d9 break;`f`b
`B100`F9d9 }`f`b

• l'instruction `B100`F9d9break;`f`b termine le bloc `B100`F9d9case`f`b (le `*cas`* à traiter). Elle est facultative dans la syntaxe Javascript. Cependant, elle est recommandée, car en son absence l'exécution continuerait dans le bloc `B100`F9d9case`f`b suivant. Dans le dernier bloc `B100`F9d9case`f`b d'un switch l'instruction `B100`F9d9break;`f`b ne sert à rien, sauf à prévoir l'éventualité où on rajouterait plus tard un bloc `B100`F9d9case`f`b supplémentaire.
• la valeur du `B100`F9d9case`f`b peut être une chaîne de caractères
• les accolades { } sont obligatoires

>>>Boucle For

Syntaxe pour plusieurs lignes d'instructions :

`B100`F9d9 for (initialisation;condition;instruction de boucle) {`f`b
`B100`F9d9 /*`f`b
`B100`F9d9 instructions exécutées à chaque passage dans la boucle`f`b
`B100`F9d9 tant que la condition est vérifiée`f`b
`B100`F9d9 */`f`b
`B100`F9d9 }`f`b

Syntaxe pour une seule instruction :

`B100`F9d9 for (initialisation;condition;instruction)`f`b

>>>Boucle For..in

`B100`F9d9 for (const Propriete in Objet) {`f`b
`B100`F9d9 //instructions utilisant Objet[Propriete];`f`b
`B100`F9d9 }`f`b

• L'itération s'effectue sur toutes les propriétés qui peuvent être associées à un compteur
• `*Cette boucle peut aussi être utilisée avec un tableau`*`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f].
• L'ensemble des propriétés balayées dans la boucle diffère selon les navigateurs. Théoriquement, cela dépend d'une propriété interne appelée "DontEnum" définie dans le standard ECMAscript, mais dans la pratique chaque navigateur renvoie un ensemble différent.

>>>Boucle While

`B100`F9d9 while (condition) {`f`b
`B100`F9d9 instruction;`f`b
`B100`F9d9 }`f`b

>>>Boucle Do..while

`B100`F9d9 do {`f`b
`B100`F9d9 instructions;`f`b
`B100`F9d9 } while (condition);`f`b

>>>Break, continue et label

`!break`! permet de sortir d'une boucle.

`!continue`! permet de passer à l'itération suivante de la boucle.

`B100`F9d9const listeFruit=["pomme","poire","banane","cerise",`f`b
`B100`F9d9 "framboise", "biscotte", "abricot", "mangue",`f`b
`B100`F9d9 "prune", "olive", "fraise"];`f`b
`B100`F9d9 for(let i = 0;i < listeFruit.length;i++) {`f`b
`B100`F9d9 const fruit = listeFruit[i];`f`b
`B100`F9d9 if(fruit == "olive"){`f`b
`B100`F9d9 break;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 if(fruit == "biscotte"){`f`b
`B100`F9d9 continue;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 console.log(fruit);`f`b
`B100`F9d9 }`f`b

Les `!label`!s permettent de "briser" (break) ou continuer (continue) plusieurs niveaux de boucles.

`B100`F9d9 const listeFruit=[["pomme","poire","banane","cerise"],`f`b
`B100`F9d9 ["framboise", "biscotte", "abricot", "mangue"],`f`b
`B100`F9d9 ["prune", "olive", "fraise"],`f`b
`B100`F9d9 ["concombre", "cresson", "haricot"]];`f`b
`B100`F9d9 listons:`f`b
`B100`F9d9 for(let i=0;i< listeFruit.length;i++) {`f`b
`B100`F9d9 const sousliste = listeFruit[i];`f`b
`B100`F9d9 for(let j = 0;j < sousliste.length;j++) {`f`b
`B100`F9d9 const fruit=sousliste[j];`f`b
`B100`F9d9 if(fruit == "olive"){`f`b
`B100`F9d9 break listons;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 if(fruit == "biscotte"){`f`b
`B100`F9d9 continue listons;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 console.log(fruit);`f`b
`B100`F9d9 }`f`b
`B100`F9d9 }`f`b

Les labels permettent aussi de sortir d'un block de code anonyme.

`B100`F9d9 const fruit = ["pomme","poire","banane","cerise"];`f`b
`B100`F9d9 listons:`f`b
`B100`F9d9 {`f`b
`B100`F9d9 console.log(fruit[0]);`f`b
`B100`F9d9 console.log(fruit[1]);`f`b
`B100`F9d9 console.log(fruit[2]);`f`b
`B100`F9d9 break listons;`f`b
`B100`F9d9 console.log(fruit[3]);`f`b
`B100`F9d9 console.log(fruit[4]);`f`b
`B100`F9d9 console.log(fruit[5]);`f`b
`B100`F9d9 }`f`b

>>Fonctions

Une `F33f`_`[fonction`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Fonction_(informatique)]`_`f est un bloc d'instructions avec une liste de paramètres (éventuellement vide). Elle possède généralement un nom et peut renvoyer une valeur.

`B100`F9d9function nom_fonction(param1, param2, param3) {`f`b
`B100`F9d9 const expression = param1 + param2 + param3;`f`b
`B100`F9d9 return expression;`f`b
`B100`F9d9}`f`b

Syntaxe pour l'appel d'une fonction anonyme, c'est-à-dire sans nom :

`B100`F9d9const fn = function(arg1, arg2) {`f`b
`B100`F9d9 //instructions;`f`b
`B100`F9d9 return expression;`f`b
`B100`F9d9};`f`b

Exemple de fonction : `F33f`_`[l'algorithme d'Euclide`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Algorithme_d'Euclide]`_`f. Il permet de trouver le plus grand commun diviseur de deux nombres, à l'aide d'une solution géométrique qui soustrait le segment le plus court du plus long`:cite-ref-2[`F5bf`_`[2`#cite-note-2]`_`f] :

`B100`F9d9 function pgcd(segmentA, segmentB) {`f`b
`B100`F9d9 while (segmentA != segmentB) {`f`b
`B100`F9d9 if (segmentA > segmentB)`f`b
`B100`F9d9 segmentA -= segmentB;`f`b
`B100`F9d9 else`f`b
`B100`F9d9 segmentB -= segmentA;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 return segmentA;`f`b
`B100`F9d9 }`f`b
`B100`F9d9const x = pgcd(60, 40); // rend 20`f`b

• le nombre des paramètres passés à l'appel de la fonction n'est pas obligatoirement égal au nombre des paramètres nommés dans la définition de la fonction
• si un paramètre nommé dans la définition de la fonction n'a pas de paramètre correspondant dans l'appel de la fonction, il reçoit la valeur `B100`F9d9undefined`f`b
• à l'intérieur de la fonction, les paramètres peuvent être accédés par l'objet `B100`F9d9arguments`f`b. Cet objet donne accès à tous les paramètres en utilisant un indice : `B100`F9d9arguments[0], arguments[1], ... arguments[n]`f`b, y compris ceux qui sont au-delà des paramètres nommés. Attention, `B100`F9d9arguments`f`b n'est `*pas`* un tableau. Il a une propriété length mais il n'a pas les méthodes des tableaux comme slice, sort, etc.
• tous les paramètres sont passés par valeur, sauf pour les objets les tableaux et les fonctions qui sont passés par référence.

`B100`F9d9 const Objet1 = {a:1}`f`b
`B100`F9d9 const Objet2 = {b:2}`f`b
`B100`F9d9 function bizarre(p) {`f`b
`B100`F9d9 let p = Objet2; // on ignore la valeur reçue dans le paramètre p`f`b
`B100`F9d9 p.b = arguments[1] // on remplit Objet2.b avec la valeur du {{2e}} paramètre reçu`f`b
`B100`F9d9 }`f`b
`B100`F9d9 bizarre(Objet1, 3) // Objet1 est ignoré, 3 est un paramètre additionnel`f`b
`B100`F9d9 console.log(\`${Objet1.a} ${Objet2.b}\`); // affiche 1 3`f`b

Il est toutefois possible de transformer l'objet `B100`F9d9arguments`f`b en un tableau grâce à :

`B100`F9d9const args = Array.prototype.slice.call(arguments);`f`b

On peut déclarer une fonction à l'intérieur d'une autre. La fonction ainsi créée pourra accéder aux variables locales de la fonction dans laquelle elle a été définie. Elle se souviendra de ces variables, même après que l'on sera sorti de la fonction dans laquelle elle a été définie, ce qui constitue une `F33f`_`[fermeture`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Fermeture_(informatique)]`_`f.

`B100`F9d9 let parfum = "vanille";`f`b
`B100`F9d9 let glace;`f`b
`B100`F9d9`f`b
`B100`F9d9 function dessert() {`f`b
`B100`F9d9 parfum = "chocolat";`f`b
`B100`F9d9 glace = function() {document.write(parfum+"<br>")};`f`b
`B100`F9d9 console.log(parfum);`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 console.log(parfum); // affiche vanille`f`b
`B100`F9d9 dessert(); // affiche "chocolat" parce qu'on est dans dessert`f`b
`B100`F9d9 console.log(parfum); // affiche vanille`f`b
`B100`F9d9 glace(); // affiche "chocolat" et pas "vanille", même si on est sorti de dessert`f`b
`B100`F9d9 console.log(parfum); // affiche vanille`f`b

>>Objets

Par commodité, on sépare habituellement les types de données en `*primitives`* (ou types de données de base) et `*objets`*. Les objets sont des entités qui ont une identité (ils ne sont égaux qu'à eux-mêmes) et qui associent des noms de propriété à des valeurs. Les propriétés sont appelées `*slots`* dans le vocabulaire de la `F33f`_`[programmation orientée prototype`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_orientée_prototype]`_`f.

Le langage Javascript propose divers types d'objets prédéfinis : `F33f`_`[tableau`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Tableau_(structure_de_données)]`_`f, `F33f`_`[booléen`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Booléen]`_`f, `F33f`_`[date`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Date]`_`f, `F33f`_`[fonction`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Fonction_informatique]`_`f, `F33f`_`[maths`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Maths]`_`f, `F33f`_`[nombre`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Nombre]`_`f, `F33f`_`[objet`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Objet_(informatique)]`_`f, `F33f`_`[expression régulière`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Expression_régulière]`_`f et `F33f`_`[chaîne de caractères`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Chaîne_de_caractères]`_`f. D'autres objets prédéfinis sont des objets `*hôte`* issus de l'environnement d'exécution. Par exemple dans un navigateur les objets hôtes appartiennent au modèle `F33f`_`[DOM`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Document_Object_Model]`_`f : `F33f`_`[fenêtre`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Fenêtre]`_`f, `F33f`_`[document`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Document]`_`f, `F33f`_`[lien hypertexte`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Hyperlien]`_`f, etc.

On peut voir les objets les plus simples comme des `F33f`_`[dictionnaires`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Tableau_associatif]`_`f. En tant que dictionnaires, ils contiennent des couples clé-valeur, où la clé est une chaîne de caractères et la valeur peut être de n'importe quel type. Les objets simples sont souvent implémentés comme des dictionnaires. Cependant, les objets possèdent des fonctionnalités que n'ont pas les dictionnaires, comme une chaîne prototype.

Exemple de déclaration littérale d'un objet contenant des valeurs :

`B100`F9d9const monObjet = {nom: 'vistemboir', utilite: 'cet objet ne sert à rien', prix: 5000};`f`b

Les propriétés des objets peuvent être créées, lues et écrites, soit avec la notation "point" objet.propriété, soit avec la syntaxe utilisée pour les éléments de tableau :

`B100`F9d9const etiquette = monObjet.nom; // etiquette contient désormais 'vistemboir'`f`b
`B100`F9d9const vente = monObjet.prix; // vente contient désormais 5000`f`b

>>>Création

Les objets peuvent être créés à l'aide d'un constructeur ou de façon littérale. Le constructeur peut utiliser la fonction prédéfinie Object ou une fonction sur mesure. Par convention les noms des fonctions constructeurs commencent par une majuscule.

`B100`F9d9// création à l'aide du constructeur prédéfini :`f`b
`B100`F9d9const premierObjet = new Object();`f`b
`B100`F9d9// création littérale :`f`b
`B100`F9d9const objetA = {};`f`b
`B100`F9d9const monObjet = {nom: 'vistemboir', utilite: 'cet objet ne sert à rien', prix: 5000};`f`b

Les déclarations littérales d'objets et de tableaux permettent de créer facilement des structures de données adaptées aux besoins :

`B100`F9d9const maStructure = {`f`b
`B100`F9d9 nom: {`f`b
`B100`F9d9 prenom: "Sylvain",`f`b
`B100`F9d9 patronyme: "Etiré"`f`b
`B100`F9d9 },`f`b
`B100`F9d9 age: 33,`f`b
`B100`F9d9 distractions: [ "oenologie", "beuveries" ]`f`b
`B100`F9d9};`f`b

C'est la base de `F33f`_`[JSON`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JSON]`_`f, un format d'échanges de données utilisant une syntaxe inspirée des objets Javascript.

>>>Constructeur

Les `F33f`_`[constructeurs`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Constructeur_(programmation_informatique)]`_`f assignent simplement des valeurs aux slots de l'objet nouvellement créé. Les valeurs assignées peuvent être elles-mêmes d'autres fonctions.

Contrairement à ce qui se passe dans d'autres langages à objets, en Javascript les objets n'ont pas de type. Le constructeur qui sert à créer l'objet n'est pas mémorisé. C'est simplement une fonction qui remplit les slots et le prototype du nouvel objet. Donc le constructeur ne correspond pas à la notion de `F33f`_`[classe`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Classe_(informatique)]`_`f qu'on trouve dans d'autres langages.

Les fonctions sont elles-mêmes des objets, ce qui peut servir à obtenir le même fonctionnement que les "static properties" des langages C++ et Java (cf exemple ci-dessous).

Les fonctions ont une propriété spécifique appelée `B100`F9d9prototype`f`b (cf paragraphe Héritage ci-dessous).

La destruction d'objet est rarement pratiquée car elle est peu nécessaire. En effet le `F33f`_`[ramasse-miettes`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ramasse-miettes_(informatique)]`_`f détruit automatiquement les objets qui ne sont plus référencés.

Exemple : manipulation d'objet

`B100`F9d9function MonObjet(attributA, attributB) {`f`b
`B100`F9d9 this.attributA = attributA;`f`b
`B100`F9d9 this.attributB = attributB;`f`b
`B100`F9d9}`f`b
`B100`F9d9`f`b
`B100`F9d9MonObjet.statiqueC = "bleu"; // ajoute à la fonction une propriété statique avec une valeur`f`b
`B100`F9d9console.log(MonObjet.statiqueC); // affiche 'bleu'`f`b
`B100`F9d9`f`b
`B100`F9d9const objet = new MonObjet('rouge', 1000);`f`b
`B100`F9d9`f`b
`B100`F9d9console.log(objet.attributA); // affiche 'rouge'`f`b
`B100`F9d9console.log(objet.attributB); // affiche 1000`f`b
`B100`F9d9`f`b
`B100`F9d9console.log(objet.statiqueC); // affiche 'undefined'`f`b
`B100`F9d9`f`b
`B100`F9d9objet.attributC = new Date(); // ajoute à l'objet une nouvelle propriété avec une valeur`f`b
`B100`F9d9`f`b
`B100`F9d9delete objet.attributB; // enlève une propriété à l'objet`f`b
`B100`F9d9console.log(objet.attributB); // affiche 'undefined'`f`b
`B100`F9d9`f`b
`B100`F9d9delete objet; // supprime l'objet entier (rarement utilisé)`f`b
`B100`F9d9console.log(objet.attributA); // déclenche une exception`f`b

>>>Méthodes

Une `F33f`_`[méthode`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Méthode_(informatique)]`_`f est simplement une fonction qui est assignée à la valeur d'un slot d'objet. Contrairement à ce qui se passe dans de nombreux langages à objets, dans Javascript il n'y a pas de distinction entre la définition d'une fonction et la définition d'une méthode. La différence peut apparaître lors de l'appel de la fonction : une fonction peut être appelée comme une méthode.

Dans l'exemple ci-dessous, la fonction Gloup assigne simplement des valeurs aux slots. Certaines de ces valeurs sont des fonctions. De cette façon Gloup peut assigner des fonctions différentes au même slot de différentes instances du même objet. N.B. Il n'y a pas de prototypage dans cet exemple.

`B100`F9d9function y2() {return this.xxx + "2 ";}`f`b
`B100`F9d9`f`b
`B100`F9d9function Gloup(xz) {`f`b
`B100`F9d9 this.xxx = "yyy-";`f`b
`B100`F9d9 if (xz > 0)`f`b
`B100`F9d9 this.xx = function() {return this.xxx +"X ";};`f`b
`B100`F9d9 else`f`b
`B100`F9d9 this.xx = function() {return this.xxx +"Z ";};`f`b
`B100`F9d9 this.yy = y2;`f`b
`B100`F9d9}`f`b
`B100`F9d9`f`b
`B100`F9d9const gloup_un = new Gloup(1);`f`b
`B100`F9d9const gloup_zero = new Gloup(0);`f`b
`B100`F9d9`f`b
`B100`F9d9gloup_zero.xxx = "aaa-";`f`b
`B100`F9d9`f`b
`B100`F9d9console.log(gloup_un.xx() + gloup_zero.xx()); // affiche yyy-X aaa-Z`f`b
`B100`F9d9`f`b
`B100`F9d9gloup_un.y3 = y2; // assigne à y3 la fonction y2 elle-même et non pas son résultat y2()`f`b
`B100`F9d9`f`b
`B100`F9d9const bloub={"xxx": "zzz-"} // création d'un objet sans utilisation de constructeur`f`b
`B100`F9d9bloub.y4 = y2 // assigne à y4 la fonction y2 elle-même et non pas son résultat y2()`f`b
`B100`F9d9`f`b
`B100`F9d9console.log(gloup_un.yy() + gloup_un.y3() + bloub.y4()); // affiche yyy-2 yyy-2 zzz-2`f`b
`B100`F9d9`f`b
`B100`F9d9gloup_un.y2(); // déclenche une exception car gloup_un.y2 n'existe pas`f`b

>>>Héritage

Javascript supporte les hiérarchies d'héritage par prototypage de la même façon que le langage `F33f`_`[self`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Self_(langage)]`_`f. Chaque objet contient un slot implicite appelé prototype.

Dans l'exemple ci-dessous, la classe Bagnole hérite de la classe Vehicule. Quand on crée l'instance b de la classe Bagnole, une référence à l'instance de base de la classe Vehicule est copiée dans b. La classe Bagnole ne contient pas de valeur pour la fonction roule. `*Quand la fonction roule est appelée`* cette fonction est recherchée dans l'arborescence d'héritage et elle est trouvée dans la classe Vehicule. Cela se voit clairement dans l'exemple : si on change la valeur de vehicule.roule, on retrouve cette valeur dans b.roule.

Les implémentations de Javascript basées sur Mozilla permettent d'accéder explicitement au prototype d'un objet grâce à un slot appelé _proto_ comme dans l'exemple ci-dessous.

`B100`F9d9function Vehicule() {`f`b
`B100`F9d9 this.roues = function() {println("nombre pair de roues");};`f`b
`B100`F9d9 this.roule = function() {println("ça roule");};`f`b
`B100`F9d9}`f`b
`B100`F9d9`f`b
`B100`F9d9function Bagnole() {`f`b
`B100`F9d9 this.roues = function() {println("quatre roues");};`f`b
`B100`F9d9// redéfinition de la fonction roues pour la classe Bagnole`f`b
`B100`F9d9}`f`b
`B100`F9d9`f`b
`B100`F9d9const vehicule = new Vehicule();`f`b
`B100`F9d9Bagnole.prototype = vehicule; // doit être exécuté avant d'instancier Bagnole`f`b
`B100`F9d9`f`b
`B100`F9d9const b = new Bagnole(); // crée b ce qui copie vehicule dans le slot prototype de b`f`b
`B100`F9d9`f`b
`B100`F9d9vehicule.roule = function() {println("ça roule sur terrain plat")}`f`b
`B100`F9d9// redéfinition de la fonction roule pour l'objet vehicule`f`b
`B100`F9d9`f`b
`B100`F9d9b.roues(); // imprime quatre roues`f`b
`B100`F9d9b.roule(); // imprime ça roule sur terrain plat`f`b
`B100`F9d9console.log(b.roule == Bagnole.prototype.roule); // affiche true`f`b
`B100`F9d9console.log(b.__proto__ == vehicule); // affiche true seulement avec Mozilla`f`b

L'exemple suivant montre clairement que les références aux prototypes sont copiées lors de la création de l'instance et que les changements appliqués au prototype se répercutent dans toutes les instances qui s'y réfèrent.

`B100`F9d9function m1() {return "un ";}`f`b
`B100`F9d9function m2() {return "deux ";}`f`b
`B100`F9d9function m3() {return "trois ";}`f`b
`B100`F9d9`f`b
`B100`F9d9function Base() {}`f`b
`B100`F9d9`f`b
`B100`F9d9Base.prototype.y = m2;`f`b
`B100`F9d9const alpha = new Base();`f`b
`B100`F9d9console.log(alpha.y()); // affiche deux`f`b
`B100`F9d9`f`b
`B100`F9d9function Special(){this.y = m3}`f`b
`B100`F9d9const special = new Special();`f`b
`B100`F9d9`f`b
`B100`F9d9const beta = new Base();`f`b
`B100`F9d9Base.prototype = special; // n'a pas d'effet sur alpha et beta qui sont déjà créés`f`b
`B100`F9d9console.log(beta.y()); // affiche deux`f`b
`B100`F9d9`f`b
`B100`F9d9const gamma = new Base(); // gamma est créé avec special dans son slot prototype`f`b
`B100`F9d9console.log(gamma.y()); // affiche trois`f`b
`B100`F9d9`f`b
`B100`F9d9special.y = m1; // impacte gamma et ses éventuelles classes dérivées`f`b
`B100`F9d9console.log(gamma.y()); // affiche un`f`b

En pratique de nombreuses variations d'héritage sont utilisées, ce qui peut être très puissant mais aussi prêter à confusion.

>>Exceptions

À partir de `F33f`_`[Internet Explorer`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Explorer]`_`f 5 et `F33f`_`[Netscape`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Netscape]`_`f 6, les implémentations de Javascript comportent une instruction `B100`F9d9try ... catch ... finally`f`b pour la `F33f`_`[gestion des exceptions`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Système_de_gestion_d'exceptions]`_`f, c'est-à-dire les erreurs en cours d'exécution. Cette instruction traite les exceptions provoquées par une erreur ou par une instruction de levée d'exception.

La syntaxe est la suivante :

`B100`F9d9try {`f`b
`B100`F9d9 // instructions pouvant déclencher une exception`f`b
`B100`F9d9} catch(erreur) {`f`b
`B100`F9d9 // instructions à exécuter en cas d'exception`f`b
`B100`F9d9} finally {`f`b
`B100`F9d9 // instructions à exécuter dans tous les cas`f`b
`B100`F9d9}`f`b

D'abord, les instructions du bloc `B100`F9d9try`f`b s'exécutent.

• si pendant l'exécution du bloc `B100`F9d9try`f`b une exception est déclenchée, l'exécution passe au bloc `B100`F9d9catch`f`b et le code de l'exception est passé dans le paramètre. À la fin du bloc `B100`F9d9catch`f`b, l'exécution continue dans le bloc `B100`F9d9finally`f`b
• si aucune exception ne se déclenche, le bloc `B100`F9d9catch`f`b est ignoré et l'exécution passe au bloc `B100`F9d9finally`f`b

Le bloc `B100`F9d9finally`f`b sert souvent à libérer la mémoire, pour éviter qu'elle ne reste bloquée lors d'une erreur fatale, même si ce souci ne se pose guère dans Javascript.

Exemple :

`B100`F9d9try {`f`b
`B100`F9d9 const tablo = new Array(); // création d'un tableau`f`b
`B100`F9d9 fonctionRisquee(tablo); // appel d'une fonction qui peut ne pas fonctionner`f`b
`B100`F9d9}`f`b
`B100`F9d9catch (...) {`f`b
`B100`F9d9 logError(); // traitement des erreurs éventuelles`f`b
`B100`F9d9}`f`b
`B100`F9d9finally {`f`b
`B100`F9d9 delete tablo; // libération de la mémoire occupée par tablo même en cas d'erreur fatale`f`b
`B100`F9d9}`f`b

Le bloc `B100`F9d9finally`f`b est facultatif :

`B100`F9d9 try {`f`b
`B100`F9d9 // instructions`f`b
`B100`F9d9 }`f`b
`B100`F9d9 catch (erreur) {`f`b
`B100`F9d9 // instructions`f`b
`B100`F9d9 }`f`b

Le bloc `B100`F9d9catch`f`b est lui aussi facultatif. Dans ce cas, si une exception se déclenche, l'exécution quitte le bloc `B100`F9d9try`f`b et passe au bloc `B100`F9d9finally`f`b sans que l'erreur soit traitée.

`B100`F9d9 try {`f`b
`B100`F9d9 // instructions`f`b
`B100`F9d9 }`f`b
`B100`F9d9 finally {`f`b
`B100`F9d9 // instructions`f`b
`B100`F9d9 }`f`b

Attention : il est obligatoire d'avoir au moins l'un des deux blocs `B100`F9d9catch`f`b ou `B100`F9d9finally`f`b, ils ne peuvent pas être absents tous les deux.

`B100`F9d9 try { instruction; } // erreur`f`b

Si vous utilisez le bloc `B100`F9d9catch`f`b, le paramètre est obligatoire, même si vous ne l'utilisez pas dans le bloc.

`B100`F9d9 try { instruction; } catch() { instruction; } // erreur`f`b

Sous Mozilla il est permis d'avoir plusieurs instructions `B100`F9d9catch`f`b. Il s'agit d'une extension au standard ECMAScript. Dans ce cas, la syntaxe est similaire à celle de `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Java_(langage)]`_`f :

`B100`F9d9try { instruction; }`f`b
`B100`F9d9catch ( e if e == "InvalidNameException" ) { instruction; }`f`b
`B100`F9d9catch ( e if e == "InvalidIdException" ) { instruction; }`f`b
`B100`F9d9catch ( e if e == "InvalidEmailException" ) { instruction; }`f`b
`B100`F9d9catch ( e ) { instruction; }`f`b

>>Divers

>>>Casse

Javascript est sensible à la casse.

L'usage est de donner aux objets un nom qui commence par une majuscule et de donner aux fonctions ou variables un nom qui commence par une minuscule.

>>>Espaces vides et points-virgules

Dans le langage Javascript les instructions se terminent par un point-virgule.

Cependant Javascript comporte un mécanisme d'insertion automatique de point-virgule : lors de l'analyse d'une `F33f`_`[ligne de code`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ligne_de_code]`_`f qui ne se termine pas par un point-virgule, si le contenu de la ligne correspond à une instruction correcte, la ligne peut être traitée comme si elle se terminait par un point-virgule.

Les caractères `F33f`_`[espace`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Barre_d'espace]`_`f, `F33f`_`[tabulation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Touche_tabulation]`_`f, `F33f`_`[fin de ligne`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Fin_de_ligne]`_`f et leurs variantes, quand ils ne sont pas inclus dans une chaîne de caractères, sont désignés sous le terme général `*whitespace`*. Les caractères whitespace peuvent avoir un effet sur le code à cause du mécanisme d'insertion automatique de point-virgule.

Pour éviter les effets non désirés dus au mécanisme d'insertion automatique de point-virgule, il est conseillé d'ajouter systématiquement un point-virgule à la fin de chaque instruction, même si cela diminue la lisibilité du code.

Exemple d'effet non désiré :

`B100`F9d9return`f`b
`B100`F9d9a + b;`f`b
`B100`F9d9// ces 2 lignes renvoient undefined car elles sont traitées comme :`f`b
`B100`F9d9// return;`f`b
`B100`F9d9// a + b;`f`b

Autre exemple :

`B100`F9d9a = b + c`f`b
`B100`F9d9(d + e).fonc()`f`b
`B100`F9d9// pas de point-virgule ajouté, les lignes sont traitées comme :`f`b
`B100`F9d9// a = b + c(d + e).fonc()`f`b

D'autre part, les caractères whitespace accroissent inutilement la taille du programme et donc du fichier .js. La solution la plus simple à ce problème est de faire comprimer les fichiers par le serveur, ce qui réduira la taille de tous les fichiers source téléchargés sur le serveur. La compression en zip fonctionne mieux que les logiciels spécialisés en suppression de whitespace (`*whitespace parser`*).

>>>Commentaires

La syntaxe des `F33f`_`[commentaires`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Commentaire_(informatique)]`_`f est la même qu'en `F33f`_`[C++`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=C++]`_`f.

`B100`F9d9// commentaire`f`b
`B100`F9d9`f`b
`B100`F9d9/* commentaire`f`b
`B100`F9d9 multiligne */`f`b

Il est interdit d'imbriquer les commentaires :

`B100`F9d9/* cette syntaxe`f`b
`B100`F9d9 /* est interdite */`f`b
`B100`F9d9*/`f`b

>>Notes et références

• (en) Cet article est partiellement ou en totalité issu de l’article de Wikipédia en anglais intitulé « JavaScript_syntax » (voir la liste des auteurs).

`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f La question est de savoir si l'itération se fera non seulement sur l'indice du tableau, mais aussi sur d'autres propriétés : Un article du site Microsoft Developer Network assure que la boucle `B100`F9d9For...In`f`b peut être utilisée pour itérer sur tous les éléments d'un tableau. L'article du MSDN se réfère à JScript, qui est utilisé par Internet Explorer pour les scripts en JavaScript. Le site W3Schools donne les tableaux comme exemple d'utilisation de la boucle `B100`F9d9For...In`f`b. Un article du Mozilla Developer Centre explique le problème : il est tentant d'utiliser la boucle `B100`F9d9For...In`f`b pour balayer les éléments d'un tableau, mais il faut savoir qu'elle balaie aussi les propriétés définies par l'utilisateur. Si vous modifiez l'objet `B100`F9d9Array`f`b en y ajoutant des propriétés ou des méthodes, la boucle `B100`F9d9For...In`f`b rendra le nom de vos propriétés en plus des indices numériques. De ce fait, pour boucler dans un tableau, il vaut mieux utiliser une boucle `B100`F9d9For`f`b classique avec un compteur numérique.
`:cite-note-2`!2.`! `F0af`_`[↑`#cite-ref-2]`_`f Les exemples présentés dans cet article utilisent souvent une fonction appelée `B100`F9d9println`f`b. Ce terme représente la fonction de `F33f`_`[sortie standard`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Flux_standard]`_`f qui n'existe pas dans la `F33f`_`[bibliothèque standard`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Bibliothèque_standard]`_`f de Javascript. Dans un navigateur, ce terme peut être remplacé par `B100`F9d9document.write`f`b.

>>>Bibliographie

• David Flanagan, Paula Ferguson: `*JavaScript: The Definitive Guide`*, O'Reilly & Associates, (`F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=International_Standard_Book_Number]`_`f 0-596-10199-6)
• Danny Goodman, Brendan Eich: `*JavaScript Bible`*, Wiley, John & Sons, (`F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=International_Standard_Book_Number]`_`f 0-7645-3342-8)
• Thomas A. Powell, Fritz Schneider: `*JavaScript: The Complete Reference`*, McGraw-Hill Companies, (`F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=International_Standard_Book_Number]`_`f 0-07-219127-9)
• Emily Vander Veer: `*JavaScript For Dummies, 4th Edition`*, Wiley, (`F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=International_Standard_Book_Number]`_`f 0-7645-7659-3)

>>Voir aussi

>>>Articles connexes

• `F33f`_`[JavaScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JavaScript]`_`f

>>>Liens externes

`!Reference material`!

• Core References for JavaScript versions 1.5

• « 1.4 » (version du 12 mai 2008 sur `*`F33f`_`[Internet Archive`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Archive]`_`f`*)
• « 1.3 » (version du 11 mai 2008 sur `*`F33f`_`[Internet Archive`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Archive]`_`f`*)
• « 1.2 » (version du 10 mai 2008 sur `*`F33f`_`[Internet Archive`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Archive]`_`f`*)

`!Ressources`!

• Mozilla JavaScript Language Documentation
• A re-introduction to JavaScript - Mozilla Developer Center

• Portail de la programmation informatique

`c`F0af`_`[↑ Back to top`#top]`_`f`a